{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.cnn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unmasked samples:  100.0\n",
      "Epoch 1/20\n",
      "96/96 [==============================] - 2s 11ms/step - loss: 3.7601 - Bandwidth_loss: 1.0575 - Duration_loss: 1.1060 - Class_loss: 1.5967 - Bandwidth_accuracy: 0.5615 - Duration_accuracy: 0.4926 - Class_accuracy: 0.3015 - val_loss: 3.3733 - val_Bandwidth_loss: 1.0324 - val_Duration_loss: 1.0377 - val_Class_loss: 1.3032 - val_Bandwidth_accuracy: 0.5333 - val_Duration_accuracy: 0.6133 - val_Class_accuracy: 0.4333\n",
      "Epoch 2/20\n",
      "96/96 [==============================] - 1s 9ms/step - loss: 2.9627 - Bandwidth_loss: 0.6562 - Duration_loss: 0.7355 - Class_loss: 1.5710 - Bandwidth_accuracy: 0.7092 - Duration_accuracy: 0.7032 - Class_accuracy: 0.3079 - val_loss: 2.7539 - val_Bandwidth_loss: 0.7910 - val_Duration_loss: 0.9036 - val_Class_loss: 1.0593 - val_Bandwidth_accuracy: 0.6733 - val_Duration_accuracy: 0.7067 - val_Class_accuracy: 0.5800\n",
      "Epoch 3/20\n",
      "96/96 [==============================] - 1s 9ms/step - loss: 2.6778 - Bandwidth_loss: 0.5221 - Duration_loss: 0.6028 - Class_loss: 1.5528 - Bandwidth_accuracy: 0.7845 - Duration_accuracy: 0.7557 - Class_accuracy: 0.3111 - val_loss: 2.1708 - val_Bandwidth_loss: 0.6888 - val_Duration_loss: 0.7121 - val_Class_loss: 0.7699 - val_Bandwidth_accuracy: 0.7200 - val_Duration_accuracy: 0.7533 - val_Class_accuracy: 0.7200\n",
      "Epoch 4/20\n",
      "96/96 [==============================] - 1s 9ms/step - loss: 2.5722 - Bandwidth_loss: 0.4780 - Duration_loss: 0.5552 - Class_loss: 1.5390 - Bandwidth_accuracy: 0.8071 - Duration_accuracy: 0.7659 - Class_accuracy: 0.3128 - val_loss: 2.1642 - val_Bandwidth_loss: 0.7151 - val_Duration_loss: 0.7715 - val_Class_loss: 0.6776 - val_Bandwidth_accuracy: 0.7267 - val_Duration_accuracy: 0.7333 - val_Class_accuracy: 0.7467\n",
      "Epoch 5/20\n",
      "96/96 [==============================] - 1s 9ms/step - loss: 2.4711 - Bandwidth_loss: 0.4265 - Duration_loss: 0.5141 - Class_loss: 1.5305 - Bandwidth_accuracy: 0.8215 - Duration_accuracy: 0.7773 - Class_accuracy: 0.3132 - val_loss: 2.0724 - val_Bandwidth_loss: 0.6988 - val_Duration_loss: 0.6972 - val_Class_loss: 0.6764 - val_Bandwidth_accuracy: 0.7400 - val_Duration_accuracy: 0.7400 - val_Class_accuracy: 0.7467\n",
      "Epoch 6/20\n",
      "96/96 [==============================] - 1s 9ms/step - loss: 2.4025 - Bandwidth_loss: 0.3958 - Duration_loss: 0.4826 - Class_loss: 1.5242 - Bandwidth_accuracy: 0.8360 - Duration_accuracy: 0.7884 - Class_accuracy: 0.3141 - val_loss: 1.5933 - val_Bandwidth_loss: 0.5136 - val_Duration_loss: 0.5927 - val_Class_loss: 0.4870 - val_Bandwidth_accuracy: 0.8000 - val_Duration_accuracy: 0.7733 - val_Class_accuracy: 0.8600\n",
      "Epoch 7/20\n",
      "96/96 [==============================] - 1s 9ms/step - loss: 2.3347 - Bandwidth_loss: 0.3587 - Duration_loss: 0.4563 - Class_loss: 1.5197 - Bandwidth_accuracy: 0.8510 - Duration_accuracy: 0.7985 - Class_accuracy: 0.3142 - val_loss: 1.4981 - val_Bandwidth_loss: 0.4744 - val_Duration_loss: 0.5719 - val_Class_loss: 0.4517 - val_Bandwidth_accuracy: 0.8333 - val_Duration_accuracy: 0.7800 - val_Class_accuracy: 0.8667\n",
      "Epoch 8/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.3308 - Bandwidth_loss: 0.3555 - Duration_loss: 0.4582 - Class_loss: 1.5171 - Bandwidth_accuracy: 0.8526 - Duration_accuracy: 0.7907 - Class_accuracy: 0.3142 - val_loss: 1.6014 - val_Bandwidth_loss: 0.5180 - val_Duration_loss: 0.5661 - val_Class_loss: 0.5173 - val_Bandwidth_accuracy: 0.8000 - val_Duration_accuracy: 0.7800 - val_Class_accuracy: 0.8267\n",
      "Epoch 9/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.2506 - Bandwidth_loss: 0.3133 - Duration_loss: 0.4218 - Class_loss: 1.5155 - Bandwidth_accuracy: 0.8692 - Duration_accuracy: 0.8062 - Class_accuracy: 0.3141 - val_loss: 1.4658 - val_Bandwidth_loss: 0.4699 - val_Duration_loss: 0.5695 - val_Class_loss: 0.4264 - val_Bandwidth_accuracy: 0.8267 - val_Duration_accuracy: 0.7000 - val_Class_accuracy: 0.8733\n",
      "Epoch 10/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.2407 - Bandwidth_loss: 0.3082 - Duration_loss: 0.4189 - Class_loss: 1.5137 - Bandwidth_accuracy: 0.8749 - Duration_accuracy: 0.8107 - Class_accuracy: 0.3145 - val_loss: 1.4529 - val_Bandwidth_loss: 0.4534 - val_Duration_loss: 0.5303 - val_Class_loss: 0.4692 - val_Bandwidth_accuracy: 0.8200 - val_Duration_accuracy: 0.8133 - val_Class_accuracy: 0.8600\n",
      "Epoch 11/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.1641 - Bandwidth_loss: 0.2637 - Duration_loss: 0.3885 - Class_loss: 1.5120 - Bandwidth_accuracy: 0.8865 - Duration_accuracy: 0.8146 - Class_accuracy: 0.3147 - val_loss: 1.4574 - val_Bandwidth_loss: 0.4491 - val_Duration_loss: 0.5426 - val_Class_loss: 0.4657 - val_Bandwidth_accuracy: 0.8333 - val_Duration_accuracy: 0.8133 - val_Class_accuracy: 0.8533\n",
      "Epoch 12/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.1549 - Bandwidth_loss: 0.2575 - Duration_loss: 0.3861 - Class_loss: 1.5113 - Bandwidth_accuracy: 0.8907 - Duration_accuracy: 0.8239 - Class_accuracy: 0.3144 - val_loss: 1.3867 - val_Bandwidth_loss: 0.4287 - val_Duration_loss: 0.5144 - val_Class_loss: 0.4437 - val_Bandwidth_accuracy: 0.8267 - val_Duration_accuracy: 0.8267 - val_Class_accuracy: 0.8600\n",
      "Epoch 13/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.1258 - Bandwidth_loss: 0.2410 - Duration_loss: 0.3743 - Class_loss: 1.5106 - Bandwidth_accuracy: 0.8992 - Duration_accuracy: 0.8252 - Class_accuracy: 0.3149 - val_loss: 1.3973 - val_Bandwidth_loss: 0.4441 - val_Duration_loss: 0.5089 - val_Class_loss: 0.4443 - val_Bandwidth_accuracy: 0.8067 - val_Duration_accuracy: 0.8200 - val_Class_accuracy: 0.8467\n",
      "Epoch 14/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.0742 - Bandwidth_loss: 0.2137 - Duration_loss: 0.3506 - Class_loss: 1.5099 - Bandwidth_accuracy: 0.9058 - Duration_accuracy: 0.8260 - Class_accuracy: 0.3149 - val_loss: 1.4241 - val_Bandwidth_loss: 0.4351 - val_Duration_loss: 0.5408 - val_Class_loss: 0.4482 - val_Bandwidth_accuracy: 0.8200 - val_Duration_accuracy: 0.8200 - val_Class_accuracy: 0.8733\n",
      "Epoch 15/20\n",
      "96/96 [==============================] - 1s 9ms/step - loss: 2.0803 - Bandwidth_loss: 0.2194 - Duration_loss: 0.3515 - Class_loss: 1.5095 - Bandwidth_accuracy: 0.9099 - Duration_accuracy: 0.8306 - Class_accuracy: 0.3149 - val_loss: 1.2982 - val_Bandwidth_loss: 0.4111 - val_Duration_loss: 0.5233 - val_Class_loss: 0.3637 - val_Bandwidth_accuracy: 0.8267 - val_Duration_accuracy: 0.8000 - val_Class_accuracy: 0.8867\n",
      "Epoch 16/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.0530 - Bandwidth_loss: 0.2092 - Duration_loss: 0.3345 - Class_loss: 1.5093 - Bandwidth_accuracy: 0.9102 - Duration_accuracy: 0.8360 - Class_accuracy: 0.3149 - val_loss: 1.3241 - val_Bandwidth_loss: 0.4099 - val_Duration_loss: 0.5350 - val_Class_loss: 0.3792 - val_Bandwidth_accuracy: 0.8667 - val_Duration_accuracy: 0.8067 - val_Class_accuracy: 0.8667\n",
      "Epoch 17/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.0354 - Bandwidth_loss: 0.1970 - Duration_loss: 0.3294 - Class_loss: 1.5091 - Bandwidth_accuracy: 0.9143 - Duration_accuracy: 0.8389 - Class_accuracy: 0.3149 - val_loss: 1.4456 - val_Bandwidth_loss: 0.4525 - val_Duration_loss: 0.5876 - val_Class_loss: 0.4055 - val_Bandwidth_accuracy: 0.8667 - val_Duration_accuracy: 0.8200 - val_Class_accuracy: 0.8933\n",
      "Epoch 18/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 2.0113 - Bandwidth_loss: 0.1904 - Duration_loss: 0.3120 - Class_loss: 1.5089 - Bandwidth_accuracy: 0.9169 - Duration_accuracy: 0.8464 - Class_accuracy: 0.3149 - val_loss: 1.4301 - val_Bandwidth_loss: 0.4398 - val_Duration_loss: 0.5678 - val_Class_loss: 0.4225 - val_Bandwidth_accuracy: 0.8400 - val_Duration_accuracy: 0.7867 - val_Class_accuracy: 0.8867\n",
      "Epoch 19/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 1.9994 - Bandwidth_loss: 0.1824 - Duration_loss: 0.3083 - Class_loss: 1.5087 - Bandwidth_accuracy: 0.9190 - Duration_accuracy: 0.8514 - Class_accuracy: 0.3150 - val_loss: 1.4982 - val_Bandwidth_loss: 0.5312 - val_Duration_loss: 0.5773 - val_Class_loss: 0.3898 - val_Bandwidth_accuracy: 0.8200 - val_Duration_accuracy: 0.7733 - val_Class_accuracy: 0.9067\n",
      "Epoch 20/20\n",
      "96/96 [==============================] - 1s 10ms/step - loss: 1.9761 - Bandwidth_loss: 0.1740 - Duration_loss: 0.2933 - Class_loss: 1.5088 - Bandwidth_accuracy: 0.9226 - Duration_accuracy: 0.8544 - Class_accuracy: 0.3149 - val_loss: 1.6618 - val_Bandwidth_loss: 0.5308 - val_Duration_loss: 0.6551 - val_Class_loss: 0.4758 - val_Bandwidth_accuracy: 0.8267 - val_Duration_accuracy: 0.8067 - val_Class_accuracy: 0.8667\n",
      "5/5 [==============================] - 0s 2ms/step - loss: 1.3616 - Bandwidth_loss: 0.3607 - Duration_loss: 0.6495 - Class_loss: 0.3515 - Bandwidth_accuracy: 0.9200 - Duration_accuracy: 0.7533 - Class_accuracy: 0.9000\n",
      "[1.3615894317626953, 0.36067891120910645, 0.6494552493095398, 0.35145530104637146, 0.9200000166893005, 0.753333330154419, 0.8999999761581421]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from keras.models import Model\n",
    "from keras.layers import Dense\n",
    "from keras.layers import multiply\n",
    "from keras.layers import Flatten\n",
    "from keras.layers import Input\n",
    "from keras.layers.convolutional import Conv1D, MaxPooling1D\n",
    "from keras.layers import Activation\n",
    "from keras.optimizers import Adam\n",
    "\n",
    "timestep = 60\n",
    "np.random.seed(10)\n",
    "\n",
    "num_class = 5\n",
    "train_sample_per_class = 20\n",
    "lambda_value = 1\n",
    "\n",
    "\n",
    "trainData = np.load(\"trainData.npy\")\n",
    "trainlabel = np.load(\"trainLabel.npy\")\n",
    "# trainData = trainData[:, -timestep*2:]\n",
    "# trainlabel = trainlabel[:, -timestep*2:]\n",
    "trainData = trainData[:, :timestep*2]\n",
    "trainlabel = trainlabel[:, :timestep*2]\n",
    "trainlabel = trainlabel.astype(int)\n",
    "\n",
    "trainmask = np.zeros((trainlabel.shape[0],256))\n",
    "\n",
    "class_counter = np.zeros((num_class))\n",
    "train_size = trainlabel.shape[0]\n",
    "j = 0\n",
    "for i in range(train_size):\n",
    "    class_id = trainlabel[i,2] - 1\n",
    "    if class_counter[class_id] < train_sample_per_class:\n",
    "        trainmask[i, :] = 1\n",
    "        j += 1\n",
    "        class_counter[class_id] += 1\n",
    "print(\"unmasked samples: \", str(np.sum(trainmask==1)/256))\n",
    "\n",
    "\n",
    "valData = np.load(\"valData.npy\")\n",
    "valLabel = np.load(\"valLabel.npy\")\n",
    "# testData = testData[:, -timestep*2:]\n",
    "# testLabel = testLabel[:, -timestep*2:]\n",
    "valData = valData[:, :timestep*2]\n",
    "valLabel = valLabel[:, :timestep*2]\n",
    "\n",
    "valLabel = valLabel.astype(int)\n",
    "valmask = np.ones((valLabel.shape[0], 256))\n",
    "valmask[:,:]=1\n",
    "\n",
    "\n",
    "testData = np.load(\"testData.npy\")\n",
    "testLabel = np.load(\"testLabel.npy\")\n",
    "# testData = testData[:, -timestep*2:]\n",
    "# testLabel = testLabel[:, -timestep*2:]\n",
    "testData = testData[:, :timestep*2]\n",
    "testLabel = testLabel[:, :timestep*2]\n",
    "\n",
    "testLabel = testLabel.astype(int)\n",
    "testmask = np.ones((testLabel.shape[0], 256))\n",
    "testmask[:,:]=1\n",
    "\n",
    "for i in range(trainlabel.shape[0]):\n",
    "    #Categorizing Bandwidth\n",
    "    if trainlabel[i, 0] < 10000:\n",
    "        trainlabel[i, 0] = 1\n",
    "    elif trainlabel[i, 0] < 50000:\n",
    "        trainlabel[i, 0] = 2\n",
    "    elif trainlabel[i, 0] < 100000:\n",
    "        trainlabel[i, 0] = 3\n",
    "    elif trainlabel[i, 0] < 1000000:\n",
    "        trainlabel[i, 0] = 4\n",
    "    else:\n",
    "        trainlabel[i, 0] = 5\n",
    "    #Categorizing Duration\n",
    "    if trainlabel[i, 1] < 10:\n",
    "        trainlabel[i, 1] = 1\n",
    "    elif trainlabel[i, 1] < 30:\n",
    "        trainlabel[i, 1] = 2\n",
    "    elif trainlabel[i, 1] < 60:\n",
    "        trainlabel[i, 1] = 3\n",
    "    else:\n",
    "        trainlabel[i, 1] = 4\n",
    "\n",
    "for i in range(valLabel.shape[0]):\n",
    "    #Categorizing Bandwidth\n",
    "    if valLabel[i, 0] < 10000:\n",
    "        valLabel[i, 0] = 1\n",
    "    elif valLabel[i, 0] < 50000:\n",
    "        valLabel[i, 0] = 2\n",
    "    elif valLabel[i, 0] < 100000:\n",
    "        valLabel[i, 0] = 3\n",
    "    elif valLabel[i, 0] < 1000000:\n",
    "        valLabel[i, 0] = 4\n",
    "    else:\n",
    "        valLabel[i, 0] = 5\n",
    "    #Categorizing Duration\n",
    "    if valLabel[i, 1] < 10:\n",
    "        valLabel[i, 1] = 1\n",
    "    elif valLabel[i, 1] < 30:\n",
    "        valLabel[i, 1] = 2\n",
    "    elif valLabel[i, 1] < 60:\n",
    "        valLabel[i, 1] = 3\n",
    "    else:\n",
    "        valLabel[i, 1] = 4\n",
    "\n",
    "\n",
    "for i in range(testLabel.shape[0]):\n",
    "    #Categorizing Bandwidth\n",
    "    if testLabel[i, 0] < 10000:\n",
    "        testLabel[i, 0] = 1\n",
    "    elif testLabel[i, 0] < 50000:\n",
    "        testLabel[i, 0] = 2\n",
    "    elif testLabel[i, 0] < 100000:\n",
    "        testLabel[i, 0] = 3\n",
    "    elif testLabel[i, 0] < 1000000:\n",
    "        testLabel[i, 0] = 4\n",
    "    else:\n",
    "        testLabel[i, 0] = 5\n",
    "    #Categorizing Duration\n",
    "    if testLabel[i, 1] < 10:\n",
    "        testLabel[i, 1] = 1\n",
    "    elif testLabel[i, 1] < 30:\n",
    "        testLabel[i, 1] = 2\n",
    "    elif testLabel[i, 1] < 60:\n",
    "        testLabel[i, 1] = 3\n",
    "    else:\n",
    "        testLabel[i, 1] = 4\n",
    "\n",
    "\n",
    "train_size = trainlabel.shape[0]\n",
    "Y_train1 = np.zeros((train_size,5))\n",
    "Y_train1[np.arange(train_size),trainlabel[:,0]-1] = 1\n",
    "Y_train2 = np.zeros((train_size,4))\n",
    "Y_train2[np.arange(train_size),trainlabel[:,1]-1] = 1\n",
    "Y_train3 = np.zeros((train_size,5))\n",
    "Y_train3[np.arange(train_size),trainlabel[:,2]-1] = 1\n",
    "\n",
    "val_size = valLabel.shape[0]\n",
    "Y_val1 = np.zeros((val_size,5))\n",
    "Y_val1[np.arange(val_size),valLabel[:,0]-1] = 1\n",
    "Y_val2 = np.zeros((val_size,4))\n",
    "Y_val2[np.arange(val_size),valLabel[:,1]-1] = 1\n",
    "Y_val3 = np.zeros((val_size,5))\n",
    "Y_val3[np.arange(val_size),valLabel[:,2]-1] = 1\n",
    "\n",
    "test_size = testLabel.shape[0]\n",
    "Y_test1 = np.zeros((test_size,5))\n",
    "Y_test1[np.arange(test_size),testLabel[:,0]-1] = 1\n",
    "Y_test2 = np.zeros((test_size,4))\n",
    "Y_test2[np.arange(test_size),testLabel[:,1]-1] = 1\n",
    "Y_test3 = np.zeros((test_size,5))\n",
    "Y_test3[np.arange(test_size),testLabel[:,2]-1] = 1\n",
    "\n",
    "# trainData = np.expand_dims(trainData, axis=-1)\n",
    "# testData = np.expand_dims(testData, axis=-1)\n",
    "trainData = trainData.reshape((trainData.shape[0], timestep, 2))\n",
    "testData = testData.reshape((testData.shape[0], timestep, 2))\n",
    "valData = valData.reshape((valData.shape[0], timestep, 2))\n",
    "\n",
    "def base_model():\n",
    "\n",
    "    model_input = Input(shape=(timestep,2))\n",
    "    mask_input = Input(shape=(256,))\n",
    "\n",
    "    x = Conv1D(32, 3, activation='relu')(model_input)\n",
    "    x = Conv1D(32, 3, activation='relu')(x)\n",
    "    x = MaxPooling1D(pool_size=(2))(x)\n",
    "\n",
    "    x = Conv1D(64, 3, activation='relu')(x)\n",
    "    x = Conv1D(64, 3, activation='relu')(x)\n",
    "    x = MaxPooling1D(pool_size=(2))(x)\n",
    "\n",
    "    x = Conv1D(128, 3, activation='relu')(x)\n",
    "    x = Conv1D(128, 3, activation='relu')(x)\n",
    "    x = MaxPooling1D(pool_size=(2))(x)\n",
    "\n",
    "    x = Flatten()(x)\n",
    "\n",
    "    x = Dense(256)(x)\n",
    "    x = Activation('relu')(x)\n",
    "    x = Dense(256)(x)\n",
    "    x = Activation('relu')(x)\n",
    "\n",
    "    output1 = Dense(5, activation='softmax', name='Bandwidth')(x)\n",
    "\n",
    "    output2 = Dense(4, activation='softmax', name='Duration')(x)\n",
    "\n",
    "    x3 = multiply([x,mask_input])\n",
    "    output3 = Dense(5, activation='softmax', name='Class')(x3)\n",
    "\n",
    "    model = Model(inputs=[model_input,mask_input], outputs=[output1, output2, output3])\n",
    "    opt = Adam(clipnorm = 1.)\n",
    "    model.compile(loss=['categorical_crossentropy', 'categorical_crossentropy', 'categorical_crossentropy'], loss_weights=[1,1,lambda_value], optimizer=opt, metrics=['accuracy'])\n",
    "\n",
    "    return model\n",
    "\n",
    "model = base_model()\n",
    "\n",
    "model.fit([trainData,trainmask], [Y_train1, Y_train2, Y_train3],\n",
    "          validation_data = ([valData, valmask], [Y_val1, Y_val2, Y_val3]),\n",
    "          batch_size = 64, epochs = 20, verbose = True, shuffle = True)\n",
    "\n",
    "result = model.evaluate([testData, testmask], [Y_test1, Y_test2, Y_test3])\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - 0s 2ms/step\n",
      "Classification Report for Bandwidth:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     1.0000    1.0000    1.0000        30\n",
      "           1     1.0000    0.9259    0.9615        27\n",
      "           2     0.6000    1.0000    0.7500         3\n",
      "           3     0.8475    0.9804    0.9091        51\n",
      "           4     0.9677    0.7692    0.8571        39\n",
      "\n",
      "    accuracy                         0.9200       150\n",
      "   macro avg     0.8830    0.9351    0.8956       150\n",
      "weighted avg     0.9317    0.9200    0.9200       150\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report for Duration:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.7551    0.8043    0.7789        46\n",
      "           1     0.9167    0.6286    0.7458        35\n",
      "           2     0.5000    0.8261    0.6230        23\n",
      "           3     0.8974    0.7609    0.8235        46\n",
      "\n",
      "    accuracy                         0.7533       150\n",
      "   macro avg     0.7673    0.7550    0.7428       150\n",
      "weighted avg     0.7973    0.7533    0.7610       150\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report for Class:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.7838    0.9667    0.8657        30\n",
      "           1     0.8276    0.8000    0.8136        30\n",
      "           2     0.9375    1.0000    0.9677        30\n",
      "           3     1.0000    1.0000    1.0000        30\n",
      "           4     1.0000    0.7333    0.8462        30\n",
      "\n",
      "    accuracy                         0.9000       150\n",
      "   macro avg     0.9098    0.9000    0.8986       150\n",
      "weighted avg     0.9098    0.9000    0.8986       150\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn import metrics\n",
    "import numpy as np\n",
    "\n",
    "# 对测试数据进行预测\n",
    "pred = model.predict([testData, testmask])\n",
    "\n",
    "# 计算每个输出的精度、召回率、F1得分和支持，并绘制混淆矩阵\n",
    "outputs = ['Bandwidth', 'Duration', 'Class']\n",
    "true_labels = [Y_test1, Y_test2, Y_test3]\n",
    "for i in range(3):\n",
    "    # 获取预测的标签\n",
    "    predicted = np.argmax(pred[i], axis=1)\n",
    "    expected = np.argmax(true_labels[i], axis=1)\n",
    "    \n",
    "    # 打印指标\n",
    "    print(f'Classification Report for {outputs[i]}:')\n",
    "    print(classification_report(expected, predicted, digits=4))\n",
    "\n",
    "    # 绘制混淆矩阵\n",
    "    cm = metrics.confusion_matrix(expected, predicted)\n",
    "    f, ax = plt.subplots(figsize=(9, 6))\n",
    "    sns.heatmap(cm, annot=True, fmt='0.6g', linewidths=1, cmap='gist_earth_r', linecolor='#666666')\n",
    "    plt.title(f'Confusion matrix for {outputs[i]}')\n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
